home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / users / ulsort / ulsort.c < prev    next >
C/C++ Source or Header  |  1996-07-10  |  13KB  |  344 lines
  1. /***********************************************************************/
  2. /*                                                                     */
  3. /*    ULSORT.C                                                         */
  4. /*                                                                     */
  5. /*   Copyright (c) 1990, James M. Curran  (of Ticketron)               */
  6. /*                                                                     */
  7. /***********************************************************************/
  8. /* Created : Wednesday, March 7, 1990 at 11:13 AM                      */
  9. /*                                                                     */
  10. /* Revision: 1.0   Last Revised: Friday, March 9, 1990 @ 4:49 PM       */
  11. /***********************************************************************/
  12. /*   Gives a short, constantly updated version of USERLIST, sorted     */
  13. /*    by login name. Press any key to exit.                   */
  14. /*                                       */
  15. /*   Use "ULSORT ?"  for complete details.                             */                                       */
  16. /*                                       */
  17. /*   Requires only MSC 5.1  (no external libraries)                    */
  18. /*                                       */
  19. /*   Should port to other (ANSI C) compilers with minimal trouble.     */
  20. /*                                       */
  21. /*   Compiles "/W3 /Za" (Maximun Warning, Force ANSI compatiblity)     */
  22. /*     without complaint.                                              */
  23. /*                                       */
  24. /*   Passes LINT with negligible complaints.                           */
  25. /*                                       */
  26. /***********************************************************************/
  27. /*                                       */
  28. /*  May be used and distributed freely (for the betterment of mankind) */
  29. /*                                       */
  30. /***********************************************************************/
  31.  
  32. #include <conio.h>
  33. #include <dos.h>
  34. #include <search.h>
  35. #include <stdlib.h>
  36. #include <stdio.h>
  37. #include <string.h>
  38. #include <time.h>
  39.  
  40.  
  41. #define DOSINT    0x21
  42. #define DOSIDLE 0x28
  43. #define CRTINT  0x10
  44.  
  45. #define BEEP        7
  46. #define DELAYTIME  10
  47.  
  48. #define    FALSE    0
  49. #define TRUE    (!FALSE)
  50.  
  51.  
  52. /*    These two structs, and the code that uses them, were stolen     */
  53. /*    from a program called WHOALL.C, which I'm told was written by   */
  54. /*    one "John Dilley".  If you need some help with them, you're     */
  55. /*    gonna have to track him down.                                   */
  56.  
  57.     struct {
  58.         int    length ;
  59.         char    function;
  60.         char    station ;
  61.         } req ;
  62.  
  63.  
  64.     struct {
  65.         int    length ;
  66.         char    uniqueid[4] ;
  67.         int    type ;
  68.         char    objectname[48] ;    /* Login name    */
  69.         char    year ;            /* Year of login */
  70.         char    month ;            /* Month "  "    */
  71.         char    day ;            /* day   "  "    */
  72.         char    hour ;            /* Hour  "  "    */
  73.         char    minute ;        /* Minute"  "    */
  74.         char    logtime[3] ;
  75.         } who ;
  76.  
  77.     char    *users[100];
  78.     
  79.     int    sort  =TRUE;
  80.     int    repeat=FALSE;
  81.     int    top   =FALSE;
  82.  
  83. /*    int    longm =FALSE;     */    
  84. /* One day I'll impilment the LONG option */
  85.  
  86. static int sortusers(char **arg1, char **arg2);
  87. static void Parse(int argc, char *argv[]);
  88.         
  89. /**********************************************************************/
  90. /**********************************************************************/
  91.  
  92. void main(int argc, char *argv[])
  93. {
  94.         union   REGS r;
  95.         char    *temp;
  96.         long    now;
  97.  
  98.     unsigned int     station;
  99.     unsigned int    i,j;
  100.     unsigned int    height;
  101.     unsigned int    OnNow;
  102.     unsigned int    OnPrev=0;
  103.  
  104.  
  105. /*    Check the command-line parameters, and set the flags.  Print    */
  106. /*    instrustions if needed                          */
  107.  
  108.     Parse(argc,argv);
  109.  
  110.     do  {
  111.         OnNow=0;
  112. /*    Here, we loop through all the possible stations (connections).  */
  113.  
  114.         for (station=1; station<100; station++) {
  115.  
  116. /*    We don't want any residue from our last loop....              */
  117.  
  118.             free(users[station]);
  119.             users[station]=NULL;
  120.  
  121. /*    This section calls INT 21h, function E3, which gets information */
  122. /*    about the person logged on the given station.  Since I stole it */
  123. /*    directly from another program, I can't go into further detail - */
  124. /*    (ie I don't know any further detail).                  */
  125.  
  126.             r.x.ax         = 0xE300 ;
  127.             r.x.si         = (int) &req;
  128.             r.x.di         = (int) &who;
  129.             who.length   = sizeof(who) ;
  130.             req.length   = sizeof(req) ;
  131.             req.function = 22 ;    /* get WHO for REQed user */
  132.             req.station  = (char) station ;
  133.             int86(DOSINT, &r, &r) ;
  134.  
  135.  
  136. /*   Here, if the given station has someone logged on, we save        */
  137. /*   thier LOGIN_NAME and station #.  Since it will print exactly 20  */
  138. /*   character for each person, they will display in columns 4 across.*/
  139.  
  140.             if (who.objectname[0]!=0){
  141.                 temp=malloc(21);
  142.                    sprintf(temp," %2i-%-16s", station,who.objectname);
  143.                 users[OnNow]=temp;
  144.                 OnNow++;
  145.                 }    /* if */
  146.  
  147. /*    Here we call Int 28h.  DOS calls this whenever it's idle.  Many */
  148. /*    TSR programs use this to avoid activating while another program */
  149. /*    is running.  Be calling it directly, we are pretending that the */ 
  150. /*    system is idle, so these other programs can run.  I did this so */
  151. /*    I could run this program and Carl Banzhof's LANUSE at the same  */
  152. /*    time.                                  */
  153.             int86(DOSIDLE, &r, &r) ;
  154.  
  155.             }            /* for */
  156.  
  157. /*   If we asked for a sorted listing, do the sort now, using the     */
  158. /*   "sortusers" (below) to determine the order.              */
  159.  
  160.         if (sort)
  161.             qsort(users,OnNow,sizeof(users[0]),sortusers);
  162.  
  163. /*   Here, we calculate the height the listing will be.  This is done */
  164. /*   by taking the number of full rows (OnNow /4, rounded down), and  */
  165. /*   adding 1 if there are any partial rows. The statement            */
  166. /*   "(OnNow % 4) > 0" equals 1 if the remainder is greater than zero,*/
  167. /*   0 otherwise.  (PC-Lint refers to this as "Unusual use of a       */
  168. /*   Boolean" -- which it is !                          */    
  169.  
  170.         height = (OnNow / 4) + ( (OnNow % 4) > 0);
  171.  
  172.  
  173.         if (repeat) {
  174.  
  175. /*   If we are repeating, move cursor so we'll overwrite the last one.*/
  176.  
  177.             r.h.ah=02;
  178.             r.h.bh=0;
  179.             r.x.dx= (top ? 0u : (24u-height) * 0x0100);
  180.             int86(CRTINT,&r,&r);
  181.  
  182.             int86(DOSIDLE, &r, &r) ;
  183.  
  184. /*    Here we compare the number of logged in users we found this time*/
  185. /*    through the loop with the number we found last time.  If they   */
  186. /*    differ (ie someone has logged on or off), it beeps.          */
  187.  
  188.             if (OnNow != OnPrev) {
  189.                 putch(BEEP);
  190.                 OnPrev=OnNow;
  191.                 }
  192.             }
  193.  
  194. /*   Print them out, in rows, going down....                  */            
  195.         
  196.         for (i=0; i<height; i++)
  197.             for (j=0;j<4; j++)
  198.                 if (users[i + j*height])
  199.                     printf(users[i + j*height]);
  200.                 else
  201.                     printf("                    ");
  202.  
  203. /*   In Use, we discovered that constantly running this program will  */
  204. /*   over strain the LAN (it pushed usage up to 30% by itself), so we */
  205. /*   added these short delay between cycles.  The length can be       */
  206. /*   adjusted by changing the #define as the top of the listing.      */
  207. /*   (Sorry, it requires a recompile to change it.)                   */
  208.  
  209.         if (repeat) {
  210.             now=time(NULL);
  211.             while (time(NULL)-now < DELAYTIME) {
  212.                 int86(DOSIDLE, &r, &r) ;
  213.                 if (kbhit())
  214.                     break;
  215.                 }
  216.             }
  217.  
  218.  
  219.  
  220.         } while (!kbhit() && repeat);
  221.  
  222. /*    At this point, the kbhit() has gotten us out of the while loop, */
  223. /*    so we remove that key from the keyboard buffer, and exit.  I    */
  224. /*    return the value of the key as ERRORLEVEL mainly to keep LINT   */
  225. /*    happy, but I imagine one display a menu from a batch file before*/
  226. /*    starting this program, or something like that.              */
  227.  
  228.     if (repeat)
  229.         exit(getch());    /*  clear keyboard buffer */
  230.     else
  231.         exit(0);
  232. }
  233.  
  234.  
  235. /*************************************************************************/
  236. /*                                                           SORTUSERS   */
  237. /*  o   Summary:                                                         */
  238. /*                                                                       */
  239. /*      int sortusers(char **arg1, char **arg2);                         */
  240. /*                                                                       */
  241. /*  o   Description:                                                     */
  242. /*      Comparision function for "qsort".  Never called directly by this */
  243. /*      program.                             */
  244. /*                                                                       */
  245. /*  o   Return Value:                                                    */
  246. /*        < 0 arg1 before arg2                                           */
  247. /*      = 0 arg1 is the same as arg2                      */
  248. /*        > 0 arg1 after  arg 2                         */
  249. /*                                                             3/ 7/1990 */
  250. /*************************************************************************/
  251.  
  252. static int sortusers(char **arg1, char **arg2)
  253. {
  254.     return(strcmp( &((*arg1)[4]), &((*arg2)[4])));
  255.  
  256. /*    That contorted line means "Compare the string pointed to by arg1   */
  257. /*    with the string pointed to by arg2, starting with a 4th character  */
  258. /*    of each."                                 */
  259. }
  260.  
  261. /*************************************************************************/
  262. /*                                                               PARSE   */
  263. /*  o   Summary:                                                         */
  264. /*                                                                       */
  265. /*      static void Parse(int argc, char *argv[]);                       */
  266. /*                                                                       */
  267. /*  o   Description:                                                     */
  268. /*       Deal with command line parameters.                              */
  269. /*                                                                       */
  270. /*  o   Return Value:                                                    */
  271. /*      None.  Sets Global flags.                                        */
  272. /*                                                             3/ 9/1990 */
  273. /*************************************************************************/
  274.  
  275. static void Parse(int argc, char *argv[])
  276. {
  277.     int    i;
  278.     int    help=FALSE;
  279.  
  280.     for (i=1; i < argc; i++) {
  281.         if (strchr(strupr(argv[i]),'S') !=NULL)/* Sort alpha */
  282.             sort=TRUE;
  283.  
  284.         if (strchr(argv[i],'R') !=NULL)        /* Repeat     */
  285.             repeat=TRUE;
  286.  
  287.         if (strchr(argv[i],'T') !=NULL)           /* Top        */
  288.             top=TRUE;
  289.  
  290. #if 0
  291.         if (strchr(argv[i],'L') !=NULL)        /* Long       */
  292.             longm=TRUE;
  293. /*     One day I'll impliment the "LONG" entry option...but not today*/
  294. #endif
  295.  
  296.         if (strchr(argv[i],'U') !=NULL)        /* Unsorted   */
  297.             sort=FALSE;
  298.  
  299.         if (strchr(argv[i],'?') !=NULL)        /* Help       */
  300.             help=TRUE;
  301.  
  302.         }
  303.     printf("ULSORT - A sorted USERLIST");
  304.     printf("                  By James M. Curran\n");
  305.  
  306.     if (!help)
  307.         printf("ULSORT  ?   for options.\n\n");
  308.     else {
  309.         printf("Usage:  ULSORT   {options}\n");
  310.         printf("Options:\n");
  311.         printf("            S    - Sort Alphabetically by Login Name.(Default)\n");
  312.         printf("            U    - Unsorted, Listed by station number.\n\n");
  313.         printf("            R    - Repeat every %d seconds until a key is pressed.\n",DELAYTIME);
  314.         printf("            T    - Displays list a top of screen.\n\n");
  315.         printf(" If Repeat mode is active, list is displayed at the bottom of\n");
  316.         printf("the screen, unless the T option is specified. T has no effect\n");
  317.         printf("unless R is specified.\n\n");
  318.         printf(" Options can be given in any order, and any of the following\n");
  319.         printf("forms will work:\n");
  320.         printf("ULSORT -t -u -r   ");
  321.         printf("ULSORT T U R    ");
  322.         printf("ULSORT tur\n\n");
  323.         }
  324.  
  325.  
  326. }
  327.  
  328. /*************************************************************************/
  329. /*   This program is provided for free, without any restrictions on it's */
  330. /*   use, distribution, modification, or cannablization.   It's also     */
  331. /*   provided without any warrantee whatsoever.  Personally, that sounds */
  332. /*   fair to me.  If you find this program interesting, or useful, or    */
  333. /*   whatever, a postcard or EasyPlex saying "Golly, James, you're a     */
  334. /*   wonderful programmer, and a credit to the human race" (or words to  */
  335. /*   that effect) would be greatly appreciated.                          */
  336. /*                                                                       */
  337. /*                                                                       */
  338. /*    James M. Curran                      CompuServe [72261,655]        */
  339. /*    24 Greendale Road                                                  */
  340. /*    Cedar Grove, NJ 07009-1313                                         */
  341. /*                                                             3/ 9/1990 */
  342. /*************************************************************************/
  343.  
  344.